// store/modules/orgTree.js

// 工具函数（需在文件顶部定义）
const flattenTree = (nodes) => {
  const result = [];
  const traverse = (node) => {
    result.push({ ...node });
    if (node.children) node.children.forEach(traverse);
  };
  nodes.forEach(traverse);
  return result;
};

const state = {
  orginTreeData: [], // 原始树数据
  flatTreeData: [], // 扁平化树数据
  checkedNodes: [], // 存储选中的节点
}

const mutations = {

  // 设置原始树数据
  SET_ORG_TREE_DATA(state, data) {
    state.orginTreeData = data
  },

  // 更新原始树数据的某个节点
  UPDATE_NODE_RECURSIVE(state, newNode) {
    const updateTree = (nodes) => nodes.map(node => {
      if (node.id === newNode.id) {
        return { ...node, ...newNode }
      }
      return node.children ? {
        ...node,
        children: updateTree(node.children)
      } : node
    })

    // 同时更新两种数据结构
    state.orginTreeData = updateTree(state.orginTreeData)

    const index = state.flatTreeData.findIndex(item => item.id === newNode.id);
    if (index > -1) {
      state.flatTreeData.splice(index, 1, {
        ...state.flatTreeData[index],
        ...newNode
      });
    }
  },


  // 设置扁平化树数据
  SET_FLAT_TREE_DATA(state, data) {
    state.flatTreeData = data
  },

  // 更新扁平化的某个节点
  UPDATE_FLAT_TREE_DATA(state, node) {
    const index = state.flatTreeData.findIndex(item => item.id === node.id)
    if (index > -1) {
      state.flatTreeData.splice(index, 1, node)
    }
  },

  // 批量更新扁平化的节点
  UPDATE_FLAT_TREE_DATA_BATCH(state, nodes) {
    nodes.forEach(node => {
      const index = state.flatTreeData.findIndex(item => item.id === node.id);
      if (index > -1) {
        state.flatTreeData.splice(index, 1, node);
      }
    });
  },

  // 添加选中节点（保持内部同步）
  ADD_CHECKED_NODE(state, node) {
    if (!state.checkedNodes.some(item => item.id === node.id)) {
      state.checkedNodes.push(node)
    }
  },

  // 移除选中节点
  REMOVE_CHECKED_NODE(state, node) {
    state.checkedNodes = state.checkedNodes.filter(item => item.id !== node.id)
  },

  // 设置选中节点
  SET_CHECKED_NODES(state, nodes) {
    state.checkedNodes = nodes
  },

  // 清空选中节点及其所有父节点的选中状态
  CLEAR_ORG_TREE_CHECKED_STATUS(state) {
    // 1. 收集需要更新的节点ID（包括自身和所有父节点）
    const nodesToUpdate = new Set();

    state.checkedNodes.forEach(node => {
      // 添加当前节点
      nodesToUpdate.add(node.id);

      // 递归添加所有父节点
      let currentId = node.parentId;
      while (currentId) {
        const parent = state.flatTreeData.find(item => item.id === currentId);
        if (parent) {
          nodesToUpdate.add(parent.id);
          currentId = parent.parentId;
        } else {
          currentId = null;
        }
      }
    });

    // 2. 更新原始树数据
    const updateTree = (nodes) => nodes.map(node => {
      if (!nodesToUpdate.has(node.id)) return node;

      const newNode = {
        ...node,
        checkedStatus: 'unchecked'
      };

      if (node.children?.length) {
        newNode.children = updateTree(node.children);
      }

      return newNode;
    });
    state.orginTreeData = updateTree(state.orginTreeData);

    // 3. 更新扁平数据
    // state.flatTreeData = state.flatTreeData.map(item =>
    //   nodesToUpdate.has(item.id)
    //     ? { ...item, checkedStatus: 'unchecked' }
    //     : item
    // );
    // 直接重新生成扁平数据（确保完全同步）
    state.flatTreeData = flattenTree(state.orginTreeData);

    // 4. 清空已选节点列表
    state.checkedNodes = [];
  },
}

const actions = {
  // 外部调用：设置原始树数据
  setOrgTreeData({ commit }, data) {
    commit('SET_ORG_TREE_DATA', data)
  },

  // 外部调用：更新原始树数据的某个节点
  updateNodeRecursive({ commit }, newNode) {
    commit('UPDATE_NODE_RECURSIVE', newNode)
  },

  // 外部调用：设置扁平化树数据
  setFlatTreeData({ commit }, data) {
    commit('SET_FLAT_TREE_DATA', data)
  },

  // 外部调用：更新扁平化的某个节点
  updateFlatTreeData({ commit }, node) {
    commit('UPDATE_FLAT_TREE_DATA', node)
  },

  // 外部调用：批量更新扁平化的节点
  updateFlatTreeDataBatch({ commit }, nodes) {
    commit('UPDATE_FLAT_TREE_DATA_BATCH', nodes)
  },

  // 外部调用：添加节点（可扩展异步逻辑）
  addNode({ commit }, node) {
    commit('ADD_CHECKED_NODE', node)
  },

  // 外部调用：移除节点
  removeNode({ commit }, node) {
    commit('REMOVE_CHECKED_NODE', node)
  },

  // 外部调用：设置节点
  setNodes({ commit }, nodes) {
    commit('SET_CHECKED_NODES', nodes)
  },

  clearNodes({ commit }) {
    commit('SET_CHECKED_NODES', [])
  },

  // 根据节点存在与否，更新选中节点
  updateCheckedNodes({ commit, state }, node) {
    if (state.checkedNodes.some(item => item.id === node.id)) {
      commit('REMOVE_CHECKED_NODE', node)
    } else {
      commit('ADD_CHECKED_NODE', node)
    }
  },

  // 清空原始树所有节点（包括子节点）的选中状态
  clearOrgTreeCheckedStatus({ commit }) {
    commit('CLEAR_ORG_TREE_CHECKED_STATUS')
  }
}

const getters = {
  checkedNodes: state => state.checkedNodes,
  checkedNodeIds: state => state.checkedNodes.map(node => node.id),
  isNodeChecked: state => id => state.checkedNodes.some(node => node.id === id)
}

export default {
  namespaced: true,
  state,
  mutations,
  actions,
  getters
}
